Crate bevy_utils

General utilities for first-party Bevy engine crates.

Re-exports

• pub use hashbrown;
• pub use petgraph;
• pub use thiserror;
• pub use tracing;

Modules

• futures
  Utilities for working with Futures.
• intern
  Provides types used to statically intern immutable values.
• label
  Traits used by label implementations
• nonmax
• prelude
• synccell
  A reimplementation of the currently unstable std::sync::Exclusive
• syncunsafecell
  A reimplementation of the currently unstable std::cell::SyncUnsafeCell

Macros

• all_tuples
  Helper macro to generate tuple pyramids. Useful to generate scaffolding to work around Rust lacking variadics. Invoking all_tuples!(impl_foo, start, end, P, Q, ..) invokes impl_foo providing ident tuples through arity start..=end.
• all_tuples_with_size
• define_label
  Macro to define a new label trait
• detailed_trace
  Like tracing::trace, but conditional on cargo feature detailed_trace.

Structs

• AHasher
  A Hasher for hashing an arbitrary stream of bytes.
• Duration
  A Duration type to represent a span of time, typically used for system timeouts.
• EntityHash
  A BuildHasher that results in a EntityHasher.
• EntityHasher
  A very fast hash that is only designed to work on generational indices like Entity. It will panic if attempting to hash a type containing non-u64 fields.
• FixedState
  A hasher builder that will create a fixed hasher.
• FloatOrd
  A wrapper for floats that implements Ord, Eq, and Hash traits.
• Hashed
  A pre-hashed value of a specific type. Pre-hashing enables memoization of hashes that are expensive to compute. It also enables faster PartialEq comparisons by short circuiting on hash equality. See PassHash and PassHasher for a “pass through” BuildHasher and Hasher implementation designed to work with Hashed See PreHashMap for a hashmap pre-configured to use Hashed keys.
• OnDrop
  A type which calls a function when dropped. This can be used to ensure that cleanup code is run even in case of a panic.
• PassHash
  A BuildHasher that results in a PassHasher.
• PassHasher
  A no-op hash that only works on u64s. Will panic if attempting to hash a type containing non-u64 fields.
• RandomState
  Provides a Hasher factory. This is typically used (e.g. by HashMap) to create AHashers in order to hash the keys of the map. See build_hasher below.
• Uuid
  A Universally Unique Identifier (UUID).

Enums

• CowArc
  Much like a Cow, but owned values are Arc-ed to make clones cheap. This should be used for values that are cloned for use across threads and change rarely (if ever).

Traits

• PreHashMapExt
  Extension methods intended to add functionality to PreHashMap.

Functions

• dbg
  Calls the tracing::debug! macro on a value.
• default
  An ergonomic abbreviation for Default::default() to make initializing structs easier. This is especially helpful when combined with “struct update syntax”.
• error
  Processes a Result by calling the tracing::error! macro in case of an Err value.
• get_short_name
  Shortens a type name to remove all module paths.
• info
  Calls the tracing::info! macro on a value.
• warn
  Processes a Result by calling the tracing::warn! macro in case of an Err value.

Type Aliases

• BoxedFuture
  An owned and dynamically typed Future used when you can’t statically type your result or need to add some indirection.
• EntityHashMap
  A HashMap pre-configured to use EntityHash hashing.
• EntityHashSet
  A HashSet pre-configured to use EntityHash hashing.
• Entry
  A shortcut alias for hashbrown::hash_map::Entry.
• HashMap
  A HashMap implementing aHash, a high speed keyed hashing algorithm intended for use in in-memory hashmaps.
• HashSet
  A HashSet implementing aHash, a high speed keyed hashing algorithm intended for use in in-memory hashmaps.
• Instant
• PreHashMap
  A HashMap pre-configured to use Hashed keys and PassHash passthrough hashing.
• StableHashMap
  A stable hash map implementing aHash, a high speed keyed hashing algorithm intended for use in in-memory hashmaps.
• StableHashSet
  A stable hash set implementing aHash, a high speed keyed hashing algorithm intended for use in in-memory hashmaps.